-- *****************************************************************************
-- *                                                    *     _       _        *
-- *  AdaDecoupe                                        *    / \   __| | __ _  *
-- *  http://code.google.com/p/adadecoupe/              *   / _ \ / _` |/ _` | *
-- *  Radim Badsi & Célia Biguzzi - IG3                 *  / ___ \ (_| | (_| | *
-- *  Polytech'Montpellier                              * /_/   \_\__,_|\__,_| *
-- *                                                    *                      *
-- *****************************************************************************
-- *                                                                           *
-- * slist.ads  -  SList                                                       *
-- * Liste générique simplement chaînée.                                       *
-- *                                                                           *
-- *****************************************************************************

generic
  type T is private;

package SList is

  type T_Liste is private;
  
  function GetCourant (L: T_Liste) return T;
  -- retourne la valeur de l'element courant
  
  --function GetCourant (L: T_Liste) return access T;
  
  procedure SetCourant (L: in out T_Liste; Elem : in T);
  
  function GetSuite (L: T_Liste) return T_Liste;
  -- retourne la suite de la SListe

  generic
    with procedure Proc (Elem : in out T);
  procedure Modifier_Element (L : in out T_Liste);

  procedure Vider (L : out T_Liste);

  procedure Ajout_Tete (L: in out T_Liste; N: in T);
  -- ajoute l'entier N en tete de SListe L
  
  procedure Ajout_Apres (L: in out T_Liste; N: in T);
  
  procedure Ajout_Fin (L: in out T_Liste; N: in T);
  -- ajoute l'entier N en fin de SListe L


  generic
  	with function Callback(Elem : T) return Boolean;
  function Cherche (L: T_Liste) return T_Liste;
 
  generic
  	with function Callback(Elem : T) return Boolean;
  	with procedure Proc (Elem : in out T);
  procedure Modifier (L: in out T_Liste);
 
  generic
    with function Callback(Elem : T) return Boolean;
  procedure Extraire (L1: in out T_Liste; L2: out T_Liste);
  -- extrait une sous-liste L2 de la liste L1 telle que quelque soit Elem
  -- (appartenant a L2), Callback(Elem) = True

  generic
    with function Callback(Elem : T) return Boolean;
  procedure Sousliste (L1: in T_Liste; L2: out T_Liste);
  
  procedure Supprime_1 (L: in out T_Liste; N: in T);
  -- supprime la premiere occurrence de N dans L
 
  procedure Supprime_Suivant (L: in out T_Liste);
 


  generic
    with function Callback (Elem : T) return Boolean;
  procedure Supprime (L : in out T_Liste; Elem : out T);
 
  generic
    with function Callback(A,B : T) return Boolean;
  procedure Tri (L: in out T_Liste);
  -- Tri la liste L (algorithme : tri a bulles). La fonction Callback renvoie True
  -- si A doit se trouver a droite de B, faux sinon.
  
  generic
    with procedure Proc(Elem : in out T);
  procedure Map(L : in out T_Liste);
  -- Appelle la procedure Proc en lui passant en parametre chaque element de la liste L

  generic
    with procedure Proc(Elem : in T);
  procedure Foreach(L : in T_Liste);
  -- Appelle la procedure Proc en lui passant en parametre chaque element de la liste L

  generic
    with function Callback(A,B : T) return Boolean;
  function Copie_Triee(L: T_Liste) return T_Liste;
  -- Cree une nouvelle SListe, qui contient les memes elements que ceux de la SListe L,
  -- mais ranges par ordre croissant
    
  function Est_Vide (t: T_Liste) return boolean;
  -- retourne TRUE si la SListe est vide, FALSE sinon

  function Cree_SListe return T_Liste;
  -- retourne la SListe vide : SListe_Vide(creer_SListe) retourne TRUE
  
  function Copie(T: T_Liste) return T_Liste;
private
  type Cell;
  type T_Liste is access Cell;
  type Cell is record
--     Val : aliased T;
	 Val : T;
     Suiv: T_Liste;
  end record;
  
  Iter_Courant : T_Liste;
end SList;
